home *** CD-ROM | disk | FTP | other *** search
/ Apple Technical Information Source 1992 September / Apple Tech I.S. 3.0 (Sept-1992).toast / Third Party SW Updates / AppMaker⁄MacApp for MacApp 3 / UAMLibraryM.cp < prev    next >
Encoding:
Text File  |  1991-06-04  |  21.6 KB  |  859 lines  |  [TEXT/MPS ]
  1. // © 1991, Bowers Development Corp.
  2. // UAMLibraryM.cp
  3.  
  4. #include "UAMLibraryM.h"
  5. #ifndef __TYPES__
  6.     #include <Types.h>
  7. #endif
  8. #ifndef __QUICKDRAW__
  9.     #include <Quickdraw.h>
  10. #endif
  11. #ifndef __RESOURCES__
  12.     #include <Resources.h>
  13. #endif
  14.  
  15. const long kStdGrayLine            = 'Line';
  16. const long kStdPalette            = 'Palt';
  17. const long kStdPictButton        = 'pBut';
  18. const long kStdPictCheckBox        = 'pChk';
  19. const long kStdPictRadio        = 'pRad';
  20. const long kStdMultiPict        = 'pMul';
  21. const long kStdSlider            = 'Sldr';
  22. const long kStdCustom            = 'Cust';
  23.  
  24.  
  25. #pragma segment AMControlRes
  26. /*----------*/
  27. pascal void ActionProcForTSlider     (ControlHandle        aCMgrControl,
  28.                                       short                partCode)
  29. {
  30.     TSlider        *aSlider;
  31.  
  32.     aSlider = (TSlider *) GetCRefCon (aCMgrControl);
  33.     FailNIL (aSlider);
  34.  
  35.     aSlider->ActionProc (partCode);
  36. } /* ActionProcForTSlider */
  37.  
  38.  
  39. //-------------------------------------------------------
  40. // TGrayLine (TView)        Gray line
  41. //-------------------------------------------------------
  42.  
  43. #pragma segment ARes
  44. /*----------*/
  45. pascal void TGrayLine::Draw        (const VRect&        area)
  46. {    
  47.     PenState        savePen;
  48.  
  49.     GetPenState (savePen);
  50.     PenNormal ();
  51.     PenPat (qd.gray);
  52. //????? the following is wrong. it should draw from view's coordinates not from rect's
  53.     MoveTo (area.left, area.top);
  54.     LineTo (area.right - 1, area.bottom - 1);
  55.  
  56.     SetPenState (savePen);
  57. } /* Draw */
  58.  
  59. //-------------------------------------------------------
  60. // TPalette (TCtlMgr)        Palette
  61. //-------------------------------------------------------
  62.  
  63. #pragma segment AOpen
  64. /*----------*/
  65. pascal void TPalette::IPalette      (TView                *itsSuperView,
  66.                                      const VPoint&        itsLocation, 
  67.                                      const VPoint&        itsSize,
  68.                                      SizeDeterminer        itsHSizeDet, 
  69.                                      SizeDeterminer        itsVSizeDet,
  70.                                      short                itsPictureID,
  71.                                      short                itsNumberAcross,
  72.                                      short                itsNumberDown,
  73.                                      short                itsFrameSize)    
  74. {
  75.     Str255        itsLabel;
  76.  
  77.     itsLabel [0] = 4;
  78.     itsLabel [1] = (Byte) (itsPictureID >> 8);
  79.     itsLabel [2] = (Byte) (itsPictureID & 0x00FF);
  80.     itsLabel [3] = (Byte) itsNumberAcross;
  81.     itsLabel [4] = (Byte) itsNumberDown;
  82.  
  83.     ICtlMgr (itsSuperView, itsLocation, itsSize, 
  84.                 itsHSizeDet, itsVSizeDet, itsLabel, 
  85.                 1, 1, (itsNumberAcross * itsNumberDown), 
  86.                 (kPaletteProcID + itsFrameSize));
  87.     fDefChoice = mPaletteHit;
  88. } /* IPalette */
  89.  
  90. #pragma segment AInit
  91. /*----------*/
  92. pascal void TPalette::IRes         (TDocument            *itsDocument,
  93.                                  TView                *itsSuperView,
  94.                                  Ptr&                itsParams)                 
  95. {
  96.     VRect            itsArea;
  97.     Str255            itsLabel;
  98.     PaletteTPtr        ptPtr;
  99.  
  100.     inherited::IRes (itsDocument, itsSuperView, itsParams);
  101.  
  102.     fDefChoice = mPaletteHit;
  103.     ptPtr = (PaletteTPtr) itsParams;
  104.     itsLabel [0] = 4;
  105.     itsLabel [1] = (Byte) (ptPtr->itsPictureID >> 8);
  106.     itsLabel [2] = (Byte) (ptPtr->itsPictureID & 0x00FF);
  107.     itsLabel [3] = (Byte) ptPtr->itsNumberAcross;
  108.     itsLabel [4] = (Byte) ptPtr->itsNumberDown;
  109.     ControlArea (itsArea);
  110.     CreateCMgrControl (itsArea, itsLabel, 1, 1, 
  111.                             (ptPtr->itsNumberDown * ptPtr->itsNumberAcross), 
  112.                             (kPaletteProcID + ptPtr->itsFrameSize));
  113.     
  114.     OffsetPtr (itsParams, sizeof (PaletteTemplate));
  115. } /* IRes */
  116.  
  117. #pragma segment WriteRes
  118. /*----------*/
  119. pascal void TPalette::WRes        (ViewRsrcHandle        theResource,
  120.                                  Ptr&                itsParams) 
  121. {
  122.     Str255            theLabel;
  123.     PaletteTPtr        ptPtr;
  124.  
  125.     inherited::WRes (theResource, itsParams);    
  126.     
  127.     GetText (theLabel);
  128.     ptPtr = (PaletteTPtr) (ExpandPtr ((Handle)theResource, itsParams,
  129.                                 sizeof (PaletteTemplate)) );
  130.     ptPtr->itsPictureID = (short) ((theLabel [1] << 8) + theLabel [2]);
  131.     ptPtr->itsNumberAcross = (short) theLabel [3];
  132.     ptPtr->itsNumberDown = (short) theLabel [4];
  133.     ptPtr->itsFrameSize = GetCVariant (fCMgrControl);
  134.  
  135. } /* WRes */
  136.  
  137. #pragma segment WriteRes
  138. /*----------*/
  139. pascal void TPalette::WriteRes          (ViewRsrcHandle        theResource,
  140.                                      Ptr&                itsParams)
  141. {
  142.     gWResSignature = kStdPalette; 
  143.     gWResType = "TPalette";
  144.     WRes (theResource, itsParams);
  145. } /* WriteRes */
  146.  
  147. #pragma segment AFields
  148. /*----------*/
  149. pascal void TPalette::Fields    (TObject*            obj)
  150. {
  151.     obj->DoToField ("TPalette", NULL, bClass);
  152.     inherited::Fields (obj);
  153. } /* Fields */
  154.  
  155. //-------------------------------------------------------
  156. // TPictButton (TCtlMgr)        Picture button
  157. //-------------------------------------------------------
  158.  
  159. #pragma segment AOpen
  160. /*----------*/
  161. pascal void TPictButton::IPictButton    (TView                *itsSuperView,
  162.                                          const VPoint&        itsLocation, 
  163.                                          const VPoint&        itsSize,
  164.                                          SizeDeterminer        itsHSizeDet, 
  165.                                          SizeDeterminer        itsVSizeDet,
  166.                                          const Str255&        itsPicts)    
  167. {
  168.     ICtlMgr (itsSuperView, itsLocation, itsSize, 
  169.                 itsHSizeDet, itsVSizeDet, itsPicts, 
  170.                 0, 0, 1, kPictButtonProcID);
  171.     fDefChoice = mButtonHit;
  172. } /* IPictButton */
  173.  
  174. #pragma segment AInit
  175. /*----------*/
  176. pascal void TPictButton::IRes         (TDocument            *itsDocument,
  177.                                      TView                *itsSuperView,
  178.                                      Ptr&                itsParams)
  179. {
  180.     VRect                itsArea;
  181.     PictControlTPtr        ptPtr;
  182.  
  183.     inherited::IRes (itsDocument, itsSuperView, itsParams);
  184.  
  185.     fDefChoice = mButtonHit;
  186.     ptPtr = (PictControlTPtr) itsParams;
  187.     ControlArea (itsArea);
  188.     CreateCMgrControl (itsArea, ptPtr->itsPictureIDs, 
  189.                             0, 0, 1, kPictButtonProcID);
  190.     
  191.     OffsetPtrWStr (itsParams, sizeof (PictControlTemplate));
  192. } /* IRes */
  193.  
  194. #pragma segment WriteRes
  195. /*----------*/
  196. pascal void TPictButton::WRes        (ViewRsrcHandle        theResource,
  197.                                      Ptr&                itsParams) 
  198. { 
  199.     Str255                theLabel;
  200.     PictControlTPtr        ptPtr;
  201.  
  202.     inherited::WRes (theResource, itsParams);    
  203.     
  204.     GetText (theLabel);
  205.     ptPtr = (PictControlTPtr) (ExpandPtrWStr ((Handle)theResource, itsParams, 
  206.                                     sizeof (PictControlTemplate), theLabel [0]));
  207.     CopyStr255 (theLabel, PRStr (ptPtr->itsPictureIDs));
  208. } /* WRes */
  209.  
  210. #pragma segment WriteRes
  211. /*----------*/
  212. pascal void TPictButton::WriteRes    (ViewRsrcHandle        theResource,
  213.                                      Ptr&                itsParams)
  214. {
  215.     gWResSignature = kStdPictButton; 
  216.     gWResType = "TPictButton";
  217.     WRes (theResource, itsParams);
  218. } /* WriteRes */
  219.  
  220. #pragma segment AFields
  221. /*----------*/
  222. pascal void TPictButton::Fields        (TObject*            obj)
  223. {
  224.     obj->DoToField ("TPictButton", NULL, bClass);
  225.     inherited::Fields (obj);
  226. } /* Fields */
  227.  
  228. //-------------------------------------------------------
  229. // TPictCheckBox (TCtlMgr)    Picture check box
  230. //-------------------------------------------------------
  231.  
  232. #pragma segment AOpen
  233. /*----------*/
  234. pascal void TPictCheckBox::IPictCheckBox    (TView                *itsSuperView,
  235.                                              const VPoint&        itsLocation, 
  236.                                              const VPoint&        itsSize,
  237.                                              SizeDeterminer        itsHSizeDet, 
  238.                                              SizeDeterminer        itsVSizeDet,
  239.                                              const Str255&        itsPicts,
  240.                                              Boolean            isTurnedOn)
  241.     
  242. {
  243.     ICtlMgr (itsSuperView, itsLocation, itsSize, 
  244.                 itsHSizeDet, itsVSizeDet, itsPicts, 
  245.                 0, 0, 1, kPictCheckProcID);
  246.     SetState (isTurnedOn, kDontRedraw);
  247.     fDefChoice = mCheckBoxHit;
  248. } /* IPictCheckBox */
  249.  
  250. #pragma segment AInit
  251. /*----------*/
  252. pascal void TPictCheckBox::IRes     (TDocument            *itsDocument,
  253.                                      TView                *itsSuperView,
  254.                                      Ptr&                itsParams)                
  255. {
  256.     VRect                itsArea;
  257.     PictControlTPtr        ptPtr;
  258.  
  259.     inherited::IRes (itsDocument, itsSuperView, itsParams);
  260.  
  261.     fDefChoice = mCheckBoxHit;
  262.     ptPtr = (PictControlTPtr) itsParams;
  263.     ControlArea (itsArea);
  264.     CreateCMgrControl (itsArea, ptPtr->itsPictureIDs, 
  265.                             0, 0, 1, kPictCheckProcID); 
  266.  
  267.     OffsetPtrWStr (itsParams, sizeof (PictControlTemplate));
  268. } /* IRes */
  269.  
  270. #pragma segment WriteRes
  271. /*----------*/
  272. pascal void TPictCheckBox::WRes        (ViewRsrcHandle        theResource,
  273.                                      Ptr&                itsParams)                 
  274. {
  275.     Str255                theLabel;
  276.     PictControlTPtr        ptPtr;
  277.  
  278.     inherited::WRes (theResource, itsParams);    
  279.     
  280.     GetText (theLabel);
  281.     ptPtr = (PictControlTPtr) (ExpandPtrWStr ((Handle)theResource, itsParams, 
  282.                                     sizeof (PictControlTemplate), theLabel [0]));
  283.     CopyStr255 (theLabel, PRStr (ptPtr->itsPictureIDs));
  284. } /* WRes */
  285.  
  286. #pragma segment WriteRes
  287. /*----------*/
  288. pascal void TPictCheckBox::WriteRes        (ViewRsrcHandle        theResource,
  289.                                          Ptr&                itsParams)                 
  290. {
  291.     gWResSignature = kStdPictCheckBox; 
  292.     gWResType = "TPictCheckBox";
  293.     WRes (theResource, itsParams);
  294. } /* WriteRes */
  295.  
  296. #pragma segment ARes
  297. /*----------*/
  298. pascal void TPictCheckBox::DoEvent    (EvtNumber            eventNumber,
  299.                                      TEvtHandler*        source,
  300.                                      TEvent*            event)            
  301. {
  302.     if (eventNumber == mCheckBoxHit) {
  303.         Toggle (kRedraw);
  304.     }
  305.     inherited::DoEvent (eventNumber, source, event);
  306. } /* DoEvent */
  307.  
  308. #pragma segment ARes
  309. /*----------*/
  310. pascal Boolean  TPictCheckBox::IsOn    (void)
  311. {
  312.     if (GetLongVal () != 0) {
  313.         return (TRUE);
  314.     } else {
  315.         return (FALSE);
  316.     }
  317. } /* IsOn */
  318.  
  319. #pragma segment ARes
  320. /*----------*/
  321. pascal void TPictCheckBox::SetState       (Boolean            state,
  322.                                         Boolean            redraw)
  323. {
  324.     SetLongVal (state, redraw);
  325. } /* SetState */
  326.  
  327. #pragma segment ARes
  328. /*----------*/
  329. pascal void TPictCheckBox::Toggle       (Boolean            redraw)
  330. {
  331.     SetLongVal (!IsOn (), redraw);
  332. } /* Toggle */
  333.  
  334. #pragma segment ARes
  335. /*----------*/
  336. pascal void TPictCheckBox::ToggleIf       (Boolean            matchState,
  337.                                         Boolean            redraw)
  338. {
  339.     if (IsOn () == matchState) {
  340.         SetLongVal (!IsOn (), redraw);
  341.     }
  342. } /* ToggleIf */
  343.  
  344. #pragma segment AFields
  345. /*----------*/
  346. pascal void TPictCheckBox::Fields    (TObject*            obj)
  347. {
  348.     obj->DoToField ("TPictCheckBox", NULL, bClass);
  349.     inherited::Fields (obj);
  350. } /* Fields */
  351.  
  352. //-------------------------------------------------------
  353. // TPictRadio (TCtlMgr)        Picture radio button
  354. //-------------------------------------------------------
  355.  
  356. #pragma segment AOpen
  357. /*----------*/
  358. pascal void TPictRadio::IPictRadio        (TView                *itsSuperView,
  359.                                          const VPoint&        itsLocation, 
  360.                                          const VPoint&        itsSize,
  361.                                          SizeDeterminer        itsHSizeDet, 
  362.                                          SizeDeterminer        itsVSizeDet,
  363.                                          const Str255&        itsPicts,
  364.                                          Boolean            isTurnedOn)    
  365. {
  366.     ICtlMgr (itsSuperView, itsLocation, itsSize, 
  367.                 itsHSizeDet, itsVSizeDet, itsPicts, 
  368.                 0, 0, 1, kPictRadioProcID);
  369.     SetState (isTurnedOn, kDontRedraw);
  370.     fDefChoice = mRadioHit;
  371. } /* IPictRadio */
  372.  
  373. #pragma segment AInit
  374. /*----------*/
  375. pascal void TPictRadio::IRes     (TDocument            *itsDocument,
  376.                                  TView                *itsSuperView,
  377.                                  Ptr&                itsParams)                
  378. {
  379.     VRect                itsArea;
  380.     PictControlTPtr        ptPtr;
  381.  
  382.     inherited::IRes (itsDocument, itsSuperView, itsParams);
  383.  
  384.     fDefChoice = mRadioHit;
  385.     ptPtr = (PictControlTPtr) itsParams;
  386.     ControlArea (itsArea);
  387.     CreateCMgrControl (itsArea, ptPtr->itsPictureIDs, 
  388.                              0, 0, 1, kPictRadioProcID); 
  389.  
  390.     OffsetPtrWStr (itsParams, sizeof (PictControlTemplate));
  391. } /* IRes */
  392.  
  393. #pragma segment WriteRes
  394. /*----------*/
  395. pascal void TPictRadio::WRes    (ViewRsrcHandle        theResource,
  396.                                  Ptr&                itsParams)                 
  397. {
  398.     Str255                theLabel;
  399.     PictControlTPtr        ptPtr;
  400.  
  401.     inherited::WRes (theResource, itsParams);    
  402.     
  403.     GetText (theLabel);
  404.     ptPtr = (PictControlTPtr) (ExpandPtrWStr ((Handle)theResource, itsParams, 
  405.                                     sizeof (PictControlTemplate), theLabel [0]));
  406.     CopyStr255 (theLabel, PRStr (ptPtr->itsPictureIDs));
  407. } /* WRes */
  408.  
  409. #pragma segment WriteRes
  410. /*----------*/
  411. pascal void TPictRadio::WriteRes    (ViewRsrcHandle        theResource,
  412.                                      Ptr&                itsParams)                 
  413. {
  414.     gWResSignature = kStdPictRadio; 
  415.     gWResType = "TPictRadio";
  416.     WRes (theResource, itsParams);
  417. } /* WriteRes */
  418.  
  419. #pragma segment ARes
  420. /*----------*/
  421. pascal void TPictRadio::DoEvent        (EvtNumber            eventNumber,
  422.                                      TEvtHandler*        source,
  423.                                      TEvent*            event)            
  424. {
  425.     if ((eventNumber == mRadioHit) && !IsOn ()) {
  426.         Toggle (kRedraw);
  427.     }
  428.     inherited::DoEvent (eventNumber, source, event);
  429. } /* DoEvent */
  430.  
  431. #pragma segment ARes
  432. /*----------*/
  433. pascal Boolean  TPictRadio::IsOn     (void)
  434. {
  435.     if (GetLongVal () != 0) {
  436.         return (TRUE);
  437.     } else {
  438.         return (FALSE);
  439.     }
  440. } /* IsOn */
  441.  
  442. #pragma segment ARes
  443. /*----------*/
  444. pascal void TPictRadio::SetState    (Boolean            state,
  445.                                      Boolean            redraw)
  446. {
  447.     SetLongVal (state, redraw);
  448. } /* SetState */
  449.  
  450. #pragma segment ARes}
  451. /*----------*/
  452. pascal void TPictRadio::Toggle        (Boolean            redraw)
  453. {
  454.     SetLongVal (!IsOn (), redraw);
  455. } /* Toggle */
  456.  
  457. #pragma segment ARes
  458. /*----------*/
  459. pascal void TPictRadio::ToggleIf    (Boolean            matchState,
  460.                                      Boolean            redraw)
  461. {
  462.     if (IsOn () == matchState) {
  463.         SetLongVal (!IsOn (), redraw);
  464.     }
  465. } /* ToggleIf */
  466.  
  467. #pragma segment AFields
  468. /*----------*/
  469. pascal void TPictRadio::Fields         (TObject*            obj)
  470. {
  471.     obj->DoToField ("TPictRadio", NULL, bClass);
  472.     inherited::Fields (obj);
  473. } /* Fields */
  474.  
  475. //-------------------------------------------------------
  476. // TMultiPict (TCtlMgr)        Multi-picture control
  477. //-------------------------------------------------------
  478.  
  479. #pragma segment AOpen
  480. /*----------*/
  481. pascal void TMultiPict::IMultiPict        (TView                *itsSuperView,
  482.                                          const VPoint&        itsLocation, 
  483.                                          const VPoint&        itsSize,
  484.                                          SizeDeterminer        itsHSizeDet, 
  485.                                          SizeDeterminer        itsVSizeDet,
  486.                                          const Str255&        itsPicts,
  487.                                          short                curValue)    
  488. {
  489.     short        numberOfPicts;        // number of possible states for the control
  490.  
  491.     numberOfPicts = itsPicts [0] / 2;    // 2 bytes for each picture ID
  492.     ICtlMgr (itsSuperView, itsLocation, itsSize, 
  493.                 itsHSizeDet, itsVSizeDet, itsPicts, 
  494.                 1, 1, numberOfPicts, kMultiPictProcID);
  495.     SetVal (curValue, kDontRedraw);
  496.     fDefChoice = mMultiPictHit;
  497. } /* IMultiPict */
  498.  
  499. #pragma segment AInit
  500. /*----------*/
  501. pascal void TMultiPict::IRes     (TDocument            *itsDocument,
  502.                                  TView                *itsSuperView,
  503.                                  Ptr&                itsParams)                
  504. {
  505.     VRect                itsArea;
  506.     PictControlTPtr        ptPtr;
  507.     short                numberOfPicts;        // number of possible states for the control
  508.  
  509.     inherited::IRes (itsDocument, itsSuperView, itsParams);
  510.  
  511.     fDefChoice = mMultiPictHit;
  512.     ptPtr = (PictControlTPtr) itsParams;
  513.     numberOfPicts = (ptPtr->itsPictureIDs [0]) / 2;        // 2 bytes for each picture ID
  514.     ControlArea (itsArea);
  515.     CreateCMgrControl (itsArea, ptPtr->itsPictureIDs, 
  516.                              1, 1, numberOfPicts, kMultiPictProcID); 
  517.  
  518.     OffsetPtrWStr (itsParams, sizeof (PictControlTemplate));
  519. } /* IRes */
  520.  
  521. #pragma segment WriteRes
  522. /*----------*/
  523. pascal void TMultiPict::WRes    (ViewRsrcHandle        theResource,
  524.                                  Ptr&                itsParams)                 
  525. {
  526.     Str255                theLabel;
  527.     PictControlTPtr        ptPtr;
  528.  
  529.     inherited::WRes (theResource, itsParams);    
  530.     
  531.     GetText (theLabel);
  532.     ptPtr = (PictControlTPtr) (ExpandPtrWStr ((Handle)theResource, itsParams, 
  533.                                     sizeof (PictControlTemplate), theLabel [0]));
  534.     CopyStr255 (theLabel, PRStr (ptPtr->itsPictureIDs));
  535. } /* WRes */
  536.  
  537. #pragma segment WriteRes
  538. /*----------*/
  539. pascal void TMultiPict::WriteRes    (ViewRsrcHandle        theResource,
  540.                                      Ptr&                itsParams)                 
  541. {
  542.     gWResSignature = kStdMultiPict; 
  543.     gWResType = "TMultiPict";
  544.     WRes (theResource, itsParams);
  545. } /* WriteRes */
  546.  
  547. #pragma segment ARes
  548. /*----------*/
  549. pascal void TMultiPict::DoEvent        (EvtNumber            eventNumber,
  550.                                      TEvtHandler*        source,
  551.                                      TEvent*            event)            
  552. {
  553.     if (eventNumber == mMultiPictHit) {
  554.         Cycle (kRedraw);
  555.     }
  556.     inherited::DoEvent (eventNumber, source, event);
  557. } /* DoEvent */
  558.  
  559. #pragma segment ARes
  560. /*----------*/
  561. pascal void TMultiPict::Cycle    (Boolean        redraw)
  562. {
  563.     short        curVal;
  564.  
  565.     curVal = GetVal ();
  566.  
  567.     if (curVal == GetMax ()) {
  568.         curVal = GetMin ();
  569.     } else {
  570.         curVal++;
  571.     }
  572.     SetVal (curVal, redraw);
  573. } /* Cycle */
  574.  
  575. #pragma segment AFields
  576. /*----------*/
  577. pascal void TMultiPict::Fields        (TObject*            obj)
  578. {
  579.     obj->DoToField ("TMultiPict", NULL, bClass);
  580.     inherited::Fields (obj);
  581. } /* Fields */
  582.  
  583. //-------------------------------------------------------
  584. // TSlider (TCtlMgr)        Custom slider
  585. //-------------------------------------------------------
  586.  
  587. #pragma segment AOpen
  588. /*----------*/
  589. pascal void TSlider::ISlider    (TView                *itsSuperView,
  590.                                  const VPoint&        itsLocation, 
  591.                                  const VPoint&        itsSize,
  592.                                  SizeDeterminer        itsHSizeDet, 
  593.                                  SizeDeterminer        itsVSizeDet,
  594.                                  VHSelect            itsDirection,
  595.                                  const Str255&        itsPicts,
  596.                                  short                itsProcID,
  597.                                  long                itsVal,
  598.                                  long                itsMin,
  599.                                  long                itsMax)    
  600. {
  601.     ICtlMgr (itsSuperView, itsLocation, itsSize, 
  602.                 itsHSizeDet, itsVSizeDet, itsPicts, itsVal, itsMin, itsMax, itsProcID);
  603.     fDirection = itsDirection;
  604.     fDefChoice = mSliderHit;
  605. } /* ISlider */
  606.  
  607. #pragma segment AInit
  608. /*----------*/
  609. pascal void TSlider::IRes     (TDocument            *itsDocument,
  610.                              TView                *itsSuperView,
  611.                              Ptr&                itsParams)                
  612. {
  613.     VRect            itsArea;
  614.     SliderTPtr        stPtr;
  615.  
  616.     inherited::IRes (itsDocument, itsSuperView, itsParams);
  617.     
  618.     fDefChoice = mSliderHit;
  619.     stPtr = (SliderTPtr) itsParams;
  620.     ControlArea (itsArea);
  621.     CreateCMgrControl (itsArea, stPtr->itsPictureIDs,
  622.                             0, 0, 10, kSliderProcID + stPtr->itsVariantCode);
  623.  
  624.     if ((itsArea.bottom - itsArea.top)
  625.     >=  (itsArea.right - itsArea.left)) {
  626.         fDirection = vSel;
  627.     } else {
  628.         fDirection = hSel;
  629.     }
  630.  
  631.     OffsetPtrWStr (itsParams, sizeof (SliderTemplate));
  632. } /* IRes */
  633.  
  634. #pragma segment WriteRes
  635. /*----------*/
  636. pascal void TSlider::WRes        (ViewRsrcHandle        theResource,
  637.                                  Ptr&                itsParams)                
  638. {
  639.     Str255            theLabel;
  640.     SliderTPtr        stPtr;
  641.  
  642.     inherited::WRes (theResource, itsParams);    
  643.     
  644.     GetText (theLabel);
  645.     stPtr = (SliderTPtr) (ExpandPtrWStr ((Handle)theResource, itsParams, 
  646.                                     sizeof (SliderTemplate), theLabel [0]));
  647.     stPtr->itsVariantCode = 0;    // should be control's variant code
  648.     CopyStr255 (theLabel, PRStr (stPtr->itsPictureIDs));
  649. } /* WRes */
  650.  
  651. #pragma segment WriteRes
  652. /*----------*/
  653. pascal void TSlider::WriteRes    (ViewRsrcHandle        theResource,
  654.                                  Ptr&                itsParams)                 
  655. {
  656.     gWResSignature = kStdSlider; 
  657.     gWResType = "TSlider";
  658.     WRes (theResource, itsParams);
  659. } /* WriteRes */
  660.  
  661. #pragma segment ARes
  662. /*----------*/
  663. pascal void TSlider::DeltaValue          (VCoordinate        delta)
  664. {
  665.     if (delta != 0) {
  666.         if (delta > 0) {
  667.             delta = Min (delta, fLongMax - fLongVal);
  668.         } else {
  669.             delta = Max (delta, fLongMin - fLongVal);
  670.         }
  671.  
  672.         SetLongVal (fLongVal + delta, TRUE);
  673.     }
  674. } /* DeltaValue */
  675.  
  676. #pragma segment ASelCommand
  677. /*----------*/
  678. pascal void TSlider::DoMouseCommand     (VPoint&            theMouse,
  679.                                          TToolboxEvent*        event,
  680.                                          Point                hysteresis)
  681. {
  682.     short            partCode;
  683.     VCoordinate        oldLongValue;
  684.     VCoordinate        newLongValue;
  685.  
  686. #if qDebug
  687.         AssumeFocused ();
  688. #endif
  689.     
  690.     oldLongValue = fLongVal;
  691.     partCode = TestControl (fCMgrControl, theMouse);
  692.     
  693.     switch (partCode) {
  694.         case inUpButton:
  695.         case inDownButton: 
  696.         case inPageUp:
  697.         case inPageDown:    
  698.                 partCode = TrackControl (fCMgrControl, theMouse, (ProcPtr)&ActionProcForTSlider);
  699.                 if (fLongVal != oldLongValue) {
  700.                     HandleEvent (fDefChoice, this, NULL);
  701.                 }
  702.             break;
  703.         case inThumb:
  704.                 if (TrackControl (fCMgrControl, theMouse, NULL) == inThumb) {
  705.                     if (GetVal () == GetMax ()) {
  706.                         newLongValue = fLongMax;
  707.                     } else {
  708.                         newLongValue = ((long) GetVal () << fBitsToShift);
  709.                     }
  710.                     SetLongVal(newLongValue, kRedraw);
  711.                 }
  712.  
  713.                 if (fLongVal != oldLongValue) {
  714.                     HandleEvent (fDefChoice, this, NULL);
  715.                 }
  716.             break;
  717.         default:
  718.             break;
  719.     } /* switch */
  720.     
  721. } /* DoMouseCommand */
  722.  
  723. #pragma segment ARes
  724. /*----------*/
  725. pascal void TSlider::TrackSlider    (short        /* partCode */)
  726. {
  727.     DeltaValue (1);        // only one part code
  728. } /* TrackSlider */
  729.  
  730. #pragma segment ASelCommand
  731. /*----------*/
  732. /* this is based on TScrollBar.ActionProc.  I'm not completely sure it's right */
  733. pascal void TSlider::ActionProc            (short        partCode)
  734. {
  735.     if (partCode != 0) {
  736.         TrackSlider (partCode);        // bounds checking?
  737.     }
  738.     Update ();
  739.     if (Focus ()) {
  740.     }
  741. } /* ActionProc */
  742.  
  743. #pragma segment AFields
  744. /*----------*/
  745. pascal void TSlider::Fields        (TObject*            obj)
  746. {
  747.     obj->DoToField ("TSlider", NULL, bClass);
  748.     obj->DoToField ("fDirection", (Ptr)&fDirection, bVHSelect);
  749.     inherited::Fields (obj);
  750. } /* Fields */
  751.  
  752. //-------------------------------------------------------
  753. // TCustom (TCtlMgr)        Other custom control
  754. //-------------------------------------------------------
  755.  
  756. struct CntlTemplate {
  757.     Rect         boundsRect;
  758.     short        value;
  759.     Boolean        visible;
  760.     Boolean        filler1;
  761.     short        max;
  762.     short        min;
  763.     short        procID;
  764.     long        refCon;
  765.     Str255        title;
  766. }; 
  767. typedef CntlTemplate *ControlTPtr, **ControlTHndl;
  768.  
  769. #pragma segment AOpen
  770. /*----------*/
  771. pascal void TCustom::ICustom     (TView                *itsSuperView,
  772.                                  const VPoint&        itsLocation, 
  773.                                  const VPoint&        itsSize,
  774.                                  SizeDeterminer        itsHSizeDet, 
  775.                                  SizeDeterminer        itsVSizeDet,
  776.                                  short                itsCntlID)    
  777. {
  778.     ControlTHndl    itsCNTL;
  779.     short            min;
  780.     short            max;
  781.  
  782.     fCntlID = itsCntlID;
  783.     itsCNTL = (ControlTHndl) Get1Resource ('CNTL', itsCntlID);
  784.     LoadResource ((Handle) itsCNTL);
  785.     HLock ((Handle) itsCNTL);
  786.     min    = (**itsCNTL).min;
  787.     max = (**itsCNTL).max;
  788.     ICtlMgr (itsSuperView, itsLocation, itsSize, 
  789.                 itsHSizeDet, itsVSizeDet, (**itsCNTL).title, 
  790.                 min, min, max, (**itsCNTL).procID);
  791.     ReleaseResource ((Handle) itsCNTL);
  792.     fDefChoice = mCustomHit;
  793. } /* ICustom */
  794.  
  795. #pragma segment AInit
  796. /*----------*/
  797. pascal void TCustom::IRes    (TDocument            *itsDocument,
  798.                              TView                *itsSuperView,
  799.                              Ptr&                itsParams)
  800. {
  801.     VRect                itsArea;
  802.     CustomControlTPtr    ctPtr;
  803.     ControlTHndl        itsCNTL;
  804.     short                min;
  805.     short                max;
  806.  
  807.     inherited::IRes (itsDocument, itsSuperView, itsParams);
  808.  
  809.     fDefChoice = mCustomHit;
  810.     ctPtr = (CustomControlTPtr) itsParams;
  811.     fCntlID = ctPtr->itsCntlID;
  812.     itsCNTL = (ControlTHndl) Get1Resource ('CNTL', ctPtr->itsCntlID);
  813.     LoadResource ((Handle) itsCNTL);
  814.     HLock ((Handle) itsCNTL);
  815.     min    = (**itsCNTL).min;
  816.     max = (**itsCNTL).max;
  817.     ControlArea (itsArea);
  818.     CreateCMgrControl (itsArea, (**itsCNTL).title, min, min, max, (**itsCNTL).procID); 
  819.     ReleaseResource ((Handle) itsCNTL);
  820.  
  821.     OffsetPtr (itsParams, sizeof (CustomControlTemplate));
  822. } /* IRes */
  823.  
  824. #pragma segment WriteRes
  825. /*----------*/
  826. pascal void TCustom::WRes    (ViewRsrcHandle        theResource,
  827.                              Ptr&                itsParams) 
  828. {
  829.     Str255                theLabel;
  830.     CustomControlTPtr    ctPtr;
  831.  
  832.     inherited::WRes (theResource, itsParams);    
  833.     
  834.     ctPtr = (CustomControlTPtr) (ExpandPtr ((Handle)theResource, itsParams, 
  835.                                     sizeof (CustomControlTemplate)) );
  836.     ctPtr->itsCntlID = fCntlID;
  837. } /* WRes */
  838.  
  839. #pragma segment WriteRes
  840. /*----------*/
  841. pascal void TCustom::WriteRes    (ViewRsrcHandle        theResource,
  842.                                  Ptr&                itsParams)
  843. {
  844.     gWResSignature = kStdCustom; 
  845.     gWResType = "TCustom";
  846.     WRes (theResource, itsParams);
  847. } /* WriteRes */
  848.  
  849. #pragma segment AFields
  850. /*----------*/
  851. pascal void TCustom::Fields        (TObject*            obj)
  852. {
  853.     obj->DoToField ("TCustom", NULL, bClass);
  854.     obj->DoToField ("fCntlID", (Ptr)&fCntlID, bInteger);
  855.     inherited::Fields (obj);
  856. } /* Fields */
  857.  
  858. /* UAMLibrary.cp */
  859.